home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / pickletester.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  29.9 KB  |  833 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import unittest
  5. import pickle
  6. import cPickle
  7. import pickletools
  8. import copy_reg
  9. from test.test_support import TestFailed, have_unicode, TESTFN
  10. if cPickle.HIGHEST_PROTOCOL == cPickle.HIGHEST_PROTOCOL:
  11.     pass
  12. elif not cPickle.HIGHEST_PROTOCOL == 2:
  13.     raise AssertionError
  14. protocols = range(pickle.HIGHEST_PROTOCOL + 1)
  15.  
  16. def opcode_in_pickle(code, pickle):
  17.     for op, dummy, dummy in pickletools.genops(pickle):
  18.         if op.code == code:
  19.             return True
  20.             continue
  21.     
  22.     return False
  23.  
  24.  
  25. def count_opcode(code, pickle):
  26.     n = 0
  27.     for op, dummy, dummy in pickletools.genops(pickle):
  28.         if op.code == code:
  29.             n += 1
  30.             continue
  31.     
  32.     return n
  33.  
  34.  
  35. class ExtensionSaver:
  36.     
  37.     def __init__(self, code):
  38.         self.code = code
  39.         if code in copy_reg._inverted_registry:
  40.             self.pair = copy_reg._inverted_registry[code]
  41.             copy_reg.remove_extension(self.pair[0], self.pair[1], code)
  42.         else:
  43.             self.pair = None
  44.  
  45.     
  46.     def restore(self):
  47.         code = self.code
  48.         curpair = copy_reg._inverted_registry.get(code)
  49.         if curpair is not None:
  50.             copy_reg.remove_extension(curpair[0], curpair[1], code)
  51.         
  52.         pair = self.pair
  53.         if pair is not None:
  54.             copy_reg.add_extension(pair[0], pair[1], code)
  55.         
  56.  
  57.  
  58.  
  59. class C:
  60.     
  61.     def __cmp__(self, other):
  62.         return cmp(self.__dict__, other.__dict__)
  63.  
  64.  
  65. import __main__
  66. __main__.C = C
  67. C.__module__ = '__main__'
  68.  
  69. class myint(int):
  70.     
  71.     def __init__(self, x):
  72.         self.str = str(x)
  73.  
  74.  
  75.  
  76. class initarg(C):
  77.     
  78.     def __init__(self, a, b):
  79.         self.a = a
  80.         self.b = b
  81.  
  82.     
  83.     def __getinitargs__(self):
  84.         return (self.a, self.b)
  85.  
  86.  
  87.  
  88. class metaclass(type):
  89.     pass
  90.  
  91.  
  92. class use_metaclass(object):
  93.     __metaclass__ = metaclass
  94.  
  95. DATA0 = '(lp1\nI0\naL1L\naF2\nac__builtin__\ncomplex\np2\n' + '(F3\nF0\ntRp3\naI1\naI-1\naI255\naI-255\naI-256\naI65535\naI-65535\naI-65536\naI2147483647\naI-2147483647\naI-2147483648\na' + "(S'abc'\np4\ng4\n" + '(i__main__\nC\np5\n' + "(dp6\nS'foo'\np7\nI1\nsS'bar'\np8\nI2\nsbg5\ntp9\nag9\naI5\na.\n"
  96. DATA0_DIS = "    0: (    MARK\n    1: l        LIST       (MARK at 0)\n    2: p    PUT        1\n    5: I    INT        0\n    8: a    APPEND\n    9: L    LONG       1L\n   13: a    APPEND\n   14: F    FLOAT      2.0\n   17: a    APPEND\n   18: c    GLOBAL     '__builtin__ complex'\n   39: p    PUT        2\n   42: (    MARK\n   43: F        FLOAT      3.0\n   46: F        FLOAT      0.0\n   49: t        TUPLE      (MARK at 42)\n   50: R    REDUCE\n   51: p    PUT        3\n   54: a    APPEND\n   55: I    INT        1\n   58: a    APPEND\n   59: I    INT        -1\n   63: a    APPEND\n   64: I    INT        255\n   69: a    APPEND\n   70: I    INT        -255\n   76: a    APPEND\n   77: I    INT        -256\n   83: a    APPEND\n   84: I    INT        65535\n   91: a    APPEND\n   92: I    INT        -65535\n  100: a    APPEND\n  101: I    INT        -65536\n  109: a    APPEND\n  110: I    INT        2147483647\n  122: a    APPEND\n  123: I    INT        -2147483647\n  136: a    APPEND\n  137: I    INT        -2147483648\n  150: a    APPEND\n  151: (    MARK\n  152: S        STRING     'abc'\n  159: p        PUT        4\n  162: g        GET        4\n  165: (        MARK\n  166: i            INST       '__main__ C' (MARK at 165)\n  178: p        PUT        5\n  181: (        MARK\n  182: d            DICT       (MARK at 181)\n  183: p        PUT        6\n  186: S        STRING     'foo'\n  193: p        PUT        7\n  196: I        INT        1\n  199: s        SETITEM\n  200: S        STRING     'bar'\n  207: p        PUT        8\n  210: I        INT        2\n  213: s        SETITEM\n  214: b        BUILD\n  215: g        GET        5\n  218: t        TUPLE      (MARK at 151)\n  219: p    PUT        9\n  222: a    APPEND\n  223: g    GET        9\n  226: a    APPEND\n  227: I    INT        5\n  230: a    APPEND\n  231: .    STOP\nhighest protocol among opcodes = 0\n"
  97. DATA1 = ']q\x01(K\x00L1L\nG@\x00\x00\x00\x00\x00\x00\x00c__builtin__\ncomplex\nq\x02(G@\x08\x00\x00\x00\x00\x00\x00G\x00\x00\x00\x00\x00\x00\x00\x00tRq\x03K\x01J\xff\xff\xff\xffK\xffJ\x01\xff\xff\xffJ\x00\xff\xff\xffM\xff\xffJ\x01\x00\xff\xffJ\x00\x00\xff\xffJ\xff\xff\xff\x7fJ\x01\x00\x00\x80J\x00\x00\x00\x80(U\x03abcq\x04h\x04(c__main__\nC\nq\x05oq\x06}q\x07(U\x03fooq\x08K\x01U\x03barq\tK\x02ubh\x06tq\nh\nK\x05e.'
  98. DATA1_DIS = "    0: ]    EMPTY_LIST\n    1: q    BINPUT     1\n    3: (    MARK\n    4: K        BININT1    0\n    6: L        LONG       1L\n   10: G        BINFLOAT   2.0\n   19: c        GLOBAL     '__builtin__ complex'\n   40: q        BINPUT     2\n   42: (        MARK\n   43: G            BINFLOAT   3.0\n   52: G            BINFLOAT   0.0\n   61: t            TUPLE      (MARK at 42)\n   62: R        REDUCE\n   63: q        BINPUT     3\n   65: K        BININT1    1\n   67: J        BININT     -1\n   72: K        BININT1    255\n   74: J        BININT     -255\n   79: J        BININT     -256\n   84: M        BININT2    65535\n   87: J        BININT     -65535\n   92: J        BININT     -65536\n   97: J        BININT     2147483647\n  102: J        BININT     -2147483647\n  107: J        BININT     -2147483648\n  112: (        MARK\n  113: U            SHORT_BINSTRING 'abc'\n  118: q            BINPUT     4\n  120: h            BINGET     4\n  122: (            MARK\n  123: c                GLOBAL     '__main__ C'\n  135: q                BINPUT     5\n  137: o                OBJ        (MARK at 122)\n  138: q            BINPUT     6\n  140: }            EMPTY_DICT\n  141: q            BINPUT     7\n  143: (            MARK\n  144: U                SHORT_BINSTRING 'foo'\n  149: q                BINPUT     8\n  151: K                BININT1    1\n  153: U                SHORT_BINSTRING 'bar'\n  158: q                BINPUT     9\n  160: K                BININT1    2\n  162: u                SETITEMS   (MARK at 143)\n  163: b            BUILD\n  164: h            BINGET     6\n  166: t            TUPLE      (MARK at 112)\n  167: q        BINPUT     10\n  169: h        BINGET     10\n  171: K        BININT1    5\n  173: e        APPENDS    (MARK at 3)\n  174: .    STOP\nhighest protocol among opcodes = 1\n"
  99. DATA2 = '\x80\x02]q\x01(K\x00\x8a\x01\x01G@\x00\x00\x00\x00\x00\x00\x00c__builtin__\ncomplex\nq\x02G@\x08\x00\x00\x00\x00\x00\x00G\x00\x00\x00\x00\x00\x00\x00\x00\x86Rq\x03K\x01J\xff\xff\xff\xffK\xffJ\x01\xff\xff\xffJ\x00\xff\xff\xffM\xff\xffJ\x01\x00\xff\xffJ\x00\x00\xff\xffJ\xff\xff\xff\x7fJ\x01\x00\x00\x80J\x00\x00\x00\x80(U\x03abcq\x04h\x04(c__main__\nC\nq\x05oq\x06}q\x07(U\x03fooq\x08K\x01U\x03barq\tK\x02ubh\x06tq\nh\nK\x05e.'
  100. DATA2_DIS = "    0: \x80 PROTO      2\n    2: ]    EMPTY_LIST\n    3: q    BINPUT     1\n    5: (    MARK\n    6: K        BININT1    0\n    8: \x8a     LONG1      1L\n   11: G        BINFLOAT   2.0\n   20: c        GLOBAL     '__builtin__ complex'\n   41: q        BINPUT     2\n   43: G        BINFLOAT   3.0\n   52: G        BINFLOAT   0.0\n   61: \x86     TUPLE2\n   62: R        REDUCE\n   63: q        BINPUT     3\n   65: K        BININT1    1\n   67: J        BININT     -1\n   72: K        BININT1    255\n   74: J        BININT     -255\n   79: J        BININT     -256\n   84: M        BININT2    65535\n   87: J        BININT     -65535\n   92: J        BININT     -65536\n   97: J        BININT     2147483647\n  102: J        BININT     -2147483647\n  107: J        BININT     -2147483648\n  112: (        MARK\n  113: U            SHORT_BINSTRING 'abc'\n  118: q            BINPUT     4\n  120: h            BINGET     4\n  122: (            MARK\n  123: c                GLOBAL     '__main__ C'\n  135: q                BINPUT     5\n  137: o                OBJ        (MARK at 122)\n  138: q            BINPUT     6\n  140: }            EMPTY_DICT\n  141: q            BINPUT     7\n  143: (            MARK\n  144: U                SHORT_BINSTRING 'foo'\n  149: q                BINPUT     8\n  151: K                BININT1    1\n  153: U                SHORT_BINSTRING 'bar'\n  158: q                BINPUT     9\n  160: K                BININT1    2\n  162: u                SETITEMS   (MARK at 143)\n  163: b            BUILD\n  164: h            BINGET     6\n  166: t            TUPLE      (MARK at 112)\n  167: q        BINPUT     10\n  169: h        BINGET     10\n  171: K        BININT1    5\n  173: e        APPENDS    (MARK at 5)\n  174: .    STOP\nhighest protocol among opcodes = 2\n"
  101.  
  102. def create_data():
  103.     c = C()
  104.     c.foo = 1
  105.     c.bar = 2
  106.     x = [
  107.         0,
  108.         0x1L,
  109.         2.0,
  110.         3.0 + (0.0+0.0j)]
  111.     uint1max = 255
  112.     uint2max = 65535
  113.     int4max = 2147483647
  114.     x.extend([
  115.         1,
  116.         -1,
  117.         uint1max,
  118.         -uint1max,
  119.         -uint1max - 1,
  120.         uint2max,
  121.         -uint2max,
  122.         -uint2max - 1,
  123.         int4max,
  124.         -int4max,
  125.         -int4max - 1])
  126.     y = ('abc', 'abc', c, c)
  127.     x.append(y)
  128.     x.append(y)
  129.     x.append(5)
  130.     return x
  131.  
  132.  
  133. class AbstractPickleTests(unittest.TestCase):
  134.     _testdata = create_data()
  135.     
  136.     def setUp(self):
  137.         pass
  138.  
  139.     
  140.     def test_misc(self):
  141.         for proto in protocols:
  142.             x = myint(4)
  143.             s = self.dumps(x, proto)
  144.             y = self.loads(s)
  145.             self.assertEqual(x, y)
  146.             x = (1, ())
  147.             s = self.dumps(x, proto)
  148.             y = self.loads(s)
  149.             self.assertEqual(x, y)
  150.             x = initarg(1, x)
  151.             s = self.dumps(x, proto)
  152.             y = self.loads(s)
  153.             self.assertEqual(x, y)
  154.         
  155.  
  156.     
  157.     def test_roundtrip_equality(self):
  158.         expected = self._testdata
  159.         for proto in protocols:
  160.             s = self.dumps(expected, proto)
  161.             got = self.loads(s)
  162.             self.assertEqual(expected, got)
  163.         
  164.  
  165.     
  166.     def test_load_from_canned_string(self):
  167.         expected = self._testdata
  168.         for canned in (DATA0, DATA1, DATA2):
  169.             got = self.loads(canned)
  170.             self.assertEqual(expected, got)
  171.         
  172.  
  173.     
  174.     def dont_test_disassembly(self):
  175.         StringIO = StringIO
  176.         import cStringIO
  177.         dis = dis
  178.         import pickletools
  179.         for proto, expected in ((0, DATA0_DIS), (1, DATA1_DIS)):
  180.             s = self.dumps(self._testdata, proto)
  181.             filelike = StringIO()
  182.             dis(s, out = filelike)
  183.             got = filelike.getvalue()
  184.             self.assertEqual(expected, got)
  185.         
  186.  
  187.     
  188.     def test_recursive_list(self):
  189.         l = []
  190.         l.append(l)
  191.         for proto in protocols:
  192.             s = self.dumps(l, proto)
  193.             x = self.loads(s)
  194.             self.assertEqual(len(x), 1)
  195.             self.assert_(x is x[0])
  196.         
  197.  
  198.     
  199.     def test_recursive_dict(self):
  200.         d = { }
  201.         d[1] = d
  202.         for proto in protocols:
  203.             s = self.dumps(d, proto)
  204.             x = self.loads(s)
  205.             self.assertEqual(x.keys(), [
  206.                 1])
  207.             self.assert_(x[1] is x)
  208.         
  209.  
  210.     
  211.     def test_recursive_inst(self):
  212.         i = C()
  213.         i.attr = i
  214.         for proto in protocols:
  215.             s = self.dumps(i, 2)
  216.             x = self.loads(s)
  217.             self.assertEqual(dir(x), dir(i))
  218.             self.assert_(x.attr is x)
  219.         
  220.  
  221.     
  222.     def test_recursive_multi(self):
  223.         l = []
  224.         d = {
  225.             1: l }
  226.         i = C()
  227.         i.attr = d
  228.         l.append(i)
  229.         for proto in protocols:
  230.             s = self.dumps(l, proto)
  231.             x = self.loads(s)
  232.             self.assertEqual(len(x), 1)
  233.             self.assertEqual(dir(x[0]), dir(i))
  234.             self.assertEqual(x[0].attr.keys(), [
  235.                 1])
  236.             self.assert_(x[0].attr[1] is x)
  237.         
  238.  
  239.     
  240.     def test_garyp(self):
  241.         self.assertRaises(self.error, self.loads, 'garyp')
  242.  
  243.     
  244.     def test_insecure_strings(self):
  245.         insecure = [
  246.             'abc',
  247.             '2 + 2',
  248.             "'abc",
  249.             '\'abc"',
  250.             "'abc'   ?",
  251.             "'\\'"]
  252.         for s in insecure:
  253.             buf = 'S' + s + '\np0\n.'
  254.             self.assertRaises(ValueError, self.loads, buf)
  255.         
  256.  
  257.     if have_unicode:
  258.         
  259.         def test_unicode(self):
  260.             endcases = [
  261.                 unicode(''),
  262.                 unicode('<\\u>'),
  263.                 unicode('<\\\\u1234>'),
  264.                 unicode('<\n>'),
  265.                 unicode('<\\>')]
  266.             for proto in protocols:
  267.                 for u in endcases:
  268.                     p = self.dumps(u, proto)
  269.                     u2 = self.loads(p)
  270.                     self.assertEqual(u2, u)
  271.                 
  272.             
  273.  
  274.     
  275.     
  276.     def test_ints(self):
  277.         import sys
  278.         for proto in protocols:
  279.             n = sys.maxint
  280.             while n:
  281.                 for expected in (-n, n):
  282.                     s = self.dumps(expected, proto)
  283.                     n2 = self.loads(s)
  284.                     self.assertEqual(expected, n2)
  285.                 
  286.                 n = n >> 1
  287.         
  288.  
  289.     
  290.     def test_maxint64(self):
  291.         maxint64 = (0x1L << 63) - 1
  292.         data = 'I' + str(maxint64) + '\n.'
  293.         got = self.loads(data)
  294.         self.assertEqual(got, maxint64)
  295.         data = 'I' + str(maxint64) + 'JUNK\n.'
  296.         self.assertRaises(ValueError, self.loads, data)
  297.  
  298.     
  299.     def test_long(self):
  300.         for proto in protocols:
  301.             for nbits in (1, 8, 8 * 254, 8 * 255, 8 * 256, 8 * 257):
  302.                 nbase = 0x1L << nbits
  303.                 for npos in (nbase - 1, nbase, nbase + 1):
  304.                     for n in (npos, -npos):
  305.                         pickle = self.dumps(n, proto)
  306.                         got = self.loads(pickle)
  307.                         self.assertEqual(n, got)
  308.                     
  309.                 
  310.             
  311.         
  312.         nbase = long('deadbeeffeedface', 16)
  313.         nbase += nbase << 1000000
  314.         for n in (nbase, -nbase):
  315.             p = self.dumps(n, 2)
  316.             got = self.loads(p)
  317.             self.assertEqual(n, got)
  318.         
  319.  
  320.     
  321.     def test_reduce(self):
  322.         pass
  323.  
  324.     
  325.     def test_getinitargs(self):
  326.         pass
  327.  
  328.     
  329.     def test_metaclass(self):
  330.         a = use_metaclass()
  331.         for proto in protocols:
  332.             s = self.dumps(a, proto)
  333.             b = self.loads(s)
  334.             self.assertEqual(a.__class__, b.__class__)
  335.         
  336.  
  337.     
  338.     def test_structseq(self):
  339.         import time
  340.         import os
  341.         t = time.localtime()
  342.         for proto in protocols:
  343.             s = self.dumps(t, proto)
  344.             u = self.loads(s)
  345.             self.assertEqual(t, u)
  346.             if hasattr(os, 'stat'):
  347.                 t = os.stat(os.curdir)
  348.                 s = self.dumps(t, proto)
  349.                 u = self.loads(s)
  350.                 self.assertEqual(t, u)
  351.             
  352.             if hasattr(os, 'statvfs'):
  353.                 t = os.statvfs(os.curdir)
  354.                 s = self.dumps(t, proto)
  355.                 u = self.loads(s)
  356.                 self.assertEqual(t, u)
  357.                 continue
  358.         
  359.  
  360.     
  361.     def test_proto(self):
  362.         build_none = pickle.NONE + pickle.STOP
  363.         for proto in protocols:
  364.             expected = build_none
  365.             if proto >= 2:
  366.                 expected = pickle.PROTO + chr(proto) + expected
  367.             
  368.             p = self.dumps(None, proto)
  369.             self.assertEqual(p, expected)
  370.         
  371.         oob = protocols[-1] + 1
  372.         badpickle = pickle.PROTO + chr(oob) + build_none
  373.         
  374.         try:
  375.             self.loads(badpickle)
  376.         except ValueError:
  377.             detail = None
  378.             self.failUnless(str(detail).startswith('unsupported pickle protocol'))
  379.  
  380.         self.fail('expected bad protocol number to raise ValueError')
  381.  
  382.     
  383.     def test_long1(self):
  384.         x = 0x27E41B32C1EEF784CCA555E8L
  385.         for proto in protocols:
  386.             s = self.dumps(x, proto)
  387.             y = self.loads(s)
  388.             self.assertEqual(x, y)
  389.             self.assertEqual(opcode_in_pickle(pickle.LONG1, s), proto >= 2)
  390.         
  391.  
  392.     
  393.     def test_long4(self):
  394.         x = 0x27E41B32C1EEF784CCA555E8L << 256 * 8
  395.         for proto in protocols:
  396.             s = self.dumps(x, proto)
  397.             y = self.loads(s)
  398.             self.assertEqual(x, y)
  399.             self.assertEqual(opcode_in_pickle(pickle.LONG4, s), proto >= 2)
  400.         
  401.  
  402.     
  403.     def test_short_tuples(self):
  404.         expected_opcode = {
  405.             (0, 0): pickle.TUPLE,
  406.             (0, 1): pickle.TUPLE,
  407.             (0, 2): pickle.TUPLE,
  408.             (0, 3): pickle.TUPLE,
  409.             (0, 4): pickle.TUPLE,
  410.             (1, 0): pickle.EMPTY_TUPLE,
  411.             (1, 1): pickle.TUPLE,
  412.             (1, 2): pickle.TUPLE,
  413.             (1, 3): pickle.TUPLE,
  414.             (1, 4): pickle.TUPLE,
  415.             (2, 0): pickle.EMPTY_TUPLE,
  416.             (2, 1): pickle.TUPLE1,
  417.             (2, 2): pickle.TUPLE2,
  418.             (2, 3): pickle.TUPLE3,
  419.             (2, 4): pickle.TUPLE }
  420.         a = ()
  421.         b = (1,)
  422.         c = (1, 2)
  423.         d = (1, 2, 3)
  424.         e = (1, 2, 3, 4)
  425.         for proto in protocols:
  426.             for x in (a, b, c, d, e):
  427.                 s = self.dumps(x, proto)
  428.                 y = self.loads(s)
  429.                 self.assertEqual(x, y, (proto, x, s, y))
  430.                 expected = expected_opcode[(proto, len(x))]
  431.                 self.assertEqual(opcode_in_pickle(expected, s), True)
  432.             
  433.         
  434.  
  435.     
  436.     def test_singletons(self):
  437.         expected_opcode = {
  438.             (0, None): pickle.NONE,
  439.             (1, None): pickle.NONE,
  440.             (2, None): pickle.NONE,
  441.             (0, True): pickle.INT,
  442.             (1, True): pickle.INT,
  443.             (2, True): pickle.NEWTRUE,
  444.             (0, False): pickle.INT,
  445.             (1, False): pickle.INT,
  446.             (2, False): pickle.NEWFALSE }
  447.         for proto in protocols:
  448.             for x in (None, False, True):
  449.                 s = self.dumps(x, proto)
  450.                 y = self.loads(s)
  451.                 self.assert_(x is y, (proto, x, s, y))
  452.                 expected = expected_opcode[(proto, x)]
  453.                 self.assertEqual(opcode_in_pickle(expected, s), True)
  454.             
  455.         
  456.  
  457.     
  458.     def test_newobj_tuple(self):
  459.         x = MyTuple([
  460.             1,
  461.             2,
  462.             3])
  463.         x.foo = 42
  464.         x.bar = 'hello'
  465.         for proto in protocols:
  466.             s = self.dumps(x, proto)
  467.             y = self.loads(s)
  468.             self.assertEqual(tuple(x), tuple(y))
  469.             self.assertEqual(x.__dict__, y.__dict__)
  470.         
  471.  
  472.     
  473.     def test_newobj_list(self):
  474.         x = MyList([
  475.             1,
  476.             2,
  477.             3])
  478.         x.foo = 42
  479.         x.bar = 'hello'
  480.         for proto in protocols:
  481.             s = self.dumps(x, proto)
  482.             y = self.loads(s)
  483.             self.assertEqual(list(x), list(y))
  484.             self.assertEqual(x.__dict__, y.__dict__)
  485.         
  486.  
  487.     
  488.     def test_newobj_generic(self):
  489.         for proto in protocols:
  490.             for C in myclasses:
  491.                 B = C.__base__
  492.                 x = C(C.sample)
  493.                 x.foo = 42
  494.                 s = self.dumps(x, proto)
  495.                 y = self.loads(s)
  496.                 detail = (proto, C, B, x, y, type(y))
  497.                 self.assertEqual(B(x), B(y), detail)
  498.                 self.assertEqual(x.__dict__, y.__dict__, detail)
  499.             
  500.         
  501.  
  502.     
  503.     def produce_global_ext(self, extcode, opcode):
  504.         e = ExtensionSaver(extcode)
  505.         
  506.         try:
  507.             copy_reg.add_extension(__name__, 'MyList', extcode)
  508.             x = MyList([
  509.                 1,
  510.                 2,
  511.                 3])
  512.             x.foo = 42
  513.             x.bar = 'hello'
  514.             s1 = self.dumps(x, 1)
  515.             self.assert_(__name__ in s1)
  516.             self.assert_('MyList' in s1)
  517.             self.assertEqual(opcode_in_pickle(opcode, s1), False)
  518.             y = self.loads(s1)
  519.             self.assertEqual(list(x), list(y))
  520.             self.assertEqual(x.__dict__, y.__dict__)
  521.             s2 = self.dumps(x, 2)
  522.             self.assert_(__name__ not in s2)
  523.             self.assert_('MyList' not in s2)
  524.             self.assertEqual(opcode_in_pickle(opcode, s2), True)
  525.             y = self.loads(s2)
  526.             self.assertEqual(list(x), list(y))
  527.             self.assertEqual(x.__dict__, y.__dict__)
  528.         finally:
  529.             e.restore()
  530.  
  531.  
  532.     
  533.     def test_global_ext1(self):
  534.         self.produce_global_ext(1, pickle.EXT1)
  535.         self.produce_global_ext(255, pickle.EXT1)
  536.  
  537.     
  538.     def test_global_ext2(self):
  539.         self.produce_global_ext(256, pickle.EXT2)
  540.         self.produce_global_ext(65535, pickle.EXT2)
  541.         self.produce_global_ext(43981, pickle.EXT2)
  542.  
  543.     
  544.     def test_global_ext4(self):
  545.         self.produce_global_ext(65536, pickle.EXT4)
  546.         self.produce_global_ext(2147483647, pickle.EXT4)
  547.         self.produce_global_ext(313249263, pickle.EXT4)
  548.  
  549.     
  550.     def test_list_chunking(self):
  551.         n = 10
  552.         x = range(n)
  553.         for proto in protocols:
  554.             s = self.dumps(x, proto)
  555.             y = self.loads(s)
  556.             self.assertEqual(x, y)
  557.             num_appends = count_opcode(pickle.APPENDS, s)
  558.             self.assertEqual(num_appends, proto > 0)
  559.         
  560.         n = 2500
  561.         x = range(n)
  562.         for proto in protocols:
  563.             s = self.dumps(x, proto)
  564.             y = self.loads(s)
  565.             self.assertEqual(x, y)
  566.             num_appends = count_opcode(pickle.APPENDS, s)
  567.             if proto == 0:
  568.                 self.assertEqual(num_appends, 0)
  569.                 continue
  570.             self.failUnless(num_appends >= 2)
  571.         
  572.  
  573.     
  574.     def test_dict_chunking(self):
  575.         n = 10
  576.         x = dict.fromkeys(range(n))
  577.         for proto in protocols:
  578.             s = self.dumps(x, proto)
  579.             y = self.loads(s)
  580.             self.assertEqual(x, y)
  581.             num_setitems = count_opcode(pickle.SETITEMS, s)
  582.             self.assertEqual(num_setitems, proto > 0)
  583.         
  584.         n = 2500
  585.         x = dict.fromkeys(range(n))
  586.         for proto in protocols:
  587.             s = self.dumps(x, proto)
  588.             y = self.loads(s)
  589.             self.assertEqual(x, y)
  590.             num_setitems = count_opcode(pickle.SETITEMS, s)
  591.             if proto == 0:
  592.                 self.assertEqual(num_setitems, 0)
  593.                 continue
  594.             self.failUnless(num_setitems >= 2)
  595.         
  596.  
  597.     
  598.     def test_simple_newobj(self):
  599.         x = object.__new__(SimpleNewObj)
  600.         x.abc = 666
  601.         for proto in protocols:
  602.             s = self.dumps(x, proto)
  603.             self.assertEqual(opcode_in_pickle(pickle.NEWOBJ, s), proto >= 2)
  604.             y = self.loads(s)
  605.             self.assertEqual(y.abc, 666)
  606.             self.assertEqual(x.__dict__, y.__dict__)
  607.         
  608.  
  609.     
  610.     def test_newobj_list_slots(self):
  611.         x = SlotList([
  612.             1,
  613.             2,
  614.             3])
  615.         x.foo = 42
  616.         x.bar = 'hello'
  617.         s = self.dumps(x, 2)
  618.         y = self.loads(s)
  619.         self.assertEqual(list(x), list(y))
  620.         self.assertEqual(x.__dict__, y.__dict__)
  621.         self.assertEqual(x.foo, y.foo)
  622.         self.assertEqual(x.bar, y.bar)
  623.  
  624.     
  625.     def test_reduce_overrides_default_reduce_ex(self):
  626.         for proto in (0, 1, 2):
  627.             x = REX_one()
  628.             self.assertEqual(x._reduce_called, 0)
  629.             s = self.dumps(x, proto)
  630.             self.assertEqual(x._reduce_called, 1)
  631.             y = self.loads(s)
  632.             self.assertEqual(y._reduce_called, 0)
  633.         
  634.  
  635.     
  636.     def test_reduce_ex_called(self):
  637.         for proto in (0, 1, 2):
  638.             x = REX_two()
  639.             self.assertEqual(x._proto, None)
  640.             s = self.dumps(x, proto)
  641.             self.assertEqual(x._proto, proto)
  642.             y = self.loads(s)
  643.             self.assertEqual(y._proto, None)
  644.         
  645.  
  646.     
  647.     def test_reduce_ex_overrides_reduce(self):
  648.         for proto in (0, 1, 2):
  649.             x = REX_three()
  650.             self.assertEqual(x._proto, None)
  651.             s = self.dumps(x, proto)
  652.             self.assertEqual(x._proto, proto)
  653.             y = self.loads(s)
  654.             self.assertEqual(y._proto, None)
  655.         
  656.  
  657.  
  658.  
  659. class REX_one(object):
  660.     _reduce_called = 0
  661.     
  662.     def __reduce__(self):
  663.         self._reduce_called = 1
  664.         return (REX_one, ())
  665.  
  666.  
  667.  
  668. class REX_two(object):
  669.     _proto = None
  670.     
  671.     def __reduce_ex__(self, proto):
  672.         self._proto = proto
  673.         return (REX_two, ())
  674.  
  675.  
  676.  
  677. class REX_three(object):
  678.     _proto = None
  679.     
  680.     def __reduce_ex__(self, proto):
  681.         self._proto = proto
  682.         return (REX_two, ())
  683.  
  684.     
  685.     def __reduce__(self):
  686.         raise TestFailed, "This __reduce__ shouldn't be called"
  687.  
  688.  
  689.  
  690. class MyInt(int):
  691.     sample = 1
  692.  
  693.  
  694. class MyLong(long):
  695.     sample = 0x1L
  696.  
  697.  
  698. class MyFloat(float):
  699.     sample = 1.0
  700.  
  701.  
  702. class MyComplex(complex):
  703.     sample = 1.0 + (0.0+0.0j)
  704.  
  705.  
  706. class MyStr(str):
  707.     sample = 'hello'
  708.  
  709.  
  710. class MyUnicode(unicode):
  711.     sample = u'hello ßê┤'
  712.  
  713.  
  714. class MyTuple(tuple):
  715.     sample = (1, 2, 3)
  716.  
  717.  
  718. class MyList(list):
  719.     sample = [
  720.         1,
  721.         2,
  722.         3]
  723.  
  724.  
  725. class MyDict(dict):
  726.     sample = {
  727.         'a': 1,
  728.         'b': 2 }
  729.  
  730. myclasses = [
  731.     MyInt,
  732.     MyLong,
  733.     MyFloat,
  734.     MyComplex,
  735.     MyStr,
  736.     MyUnicode,
  737.     MyTuple,
  738.     MyList,
  739.     MyDict]
  740.  
  741. class SlotList(MyList):
  742.     __slots__ = [
  743.         'foo']
  744.  
  745.  
  746. class SimpleNewObj(object):
  747.     
  748.     def __init__(self, a, b, c):
  749.         raise TypeError("SimpleNewObj.__init__() didn't expect to get called")
  750.  
  751.  
  752.  
  753. class AbstractPickleModuleTests(unittest.TestCase):
  754.     
  755.     def test_dump_closed_file(self):
  756.         import os
  757.         f = open(TESTFN, 'w')
  758.         
  759.         try:
  760.             f.close()
  761.             self.assertRaises(ValueError, self.module.dump, 123, f)
  762.         finally:
  763.             os.remove(TESTFN)
  764.  
  765.  
  766.     
  767.     def test_load_closed_file(self):
  768.         import os
  769.         f = open(TESTFN, 'w')
  770.         
  771.         try:
  772.             f.close()
  773.             self.assertRaises(ValueError, self.module.dump, 123, f)
  774.         finally:
  775.             os.remove(TESTFN)
  776.  
  777.  
  778.     
  779.     def test_highest_protocol(self):
  780.         self.assertEqual(self.module.HIGHEST_PROTOCOL, 2)
  781.  
  782.     
  783.     def test_callapi(self):
  784.         StringIO = StringIO
  785.         import cStringIO
  786.         f = StringIO()
  787.         self.module.dump(123, f, -1)
  788.         self.module.dump(123, file = f, protocol = -1)
  789.         self.module.dumps(123, -1)
  790.         self.module.dumps(123, protocol = -1)
  791.         self.module.Pickler(f, -1)
  792.         self.module.Pickler(f, protocol = -1)
  793.  
  794.  
  795.  
  796. class AbstractPersistentPicklerTests(unittest.TestCase):
  797.     
  798.     def persistent_id(self, object):
  799.         if isinstance(object, int) and object % 2 == 0:
  800.             self.id_count += 1
  801.             return str(object)
  802.         else:
  803.             return None
  804.  
  805.     
  806.     def persistent_load(self, oid):
  807.         self.load_count += 1
  808.         object = int(oid)
  809.         if not object % 2 == 0:
  810.             raise AssertionError
  811.         self
  812.         return object
  813.  
  814.     
  815.     def test_persistence(self):
  816.         self.id_count = 0
  817.         self.load_count = 0
  818.         L = range(10)
  819.         self.assertEqual(self.loads(self.dumps(L)), L)
  820.         self.assertEqual(self.id_count, 5)
  821.         self.assertEqual(self.load_count, 5)
  822.  
  823.     
  824.     def test_bin_persistence(self):
  825.         self.id_count = 0
  826.         self.load_count = 0
  827.         L = range(10)
  828.         self.assertEqual(self.loads(self.dumps(L, 1)), L)
  829.         self.assertEqual(self.id_count, 5)
  830.         self.assertEqual(self.load_count, 5)
  831.  
  832.  
  833.